{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LSA\n",
    "\n",
    "Latent Semantic Analysis (LSA) is a theory and method for extracting and representing the contextual-usage meaning of words by statistical computations applied to a large corpus of text.\n",
    "\n",
    "LSA is an information retrieval technique which analyzes and identifies the pattern in unstructured collection of text and the relationship between them.\n",
    "\n",
    "LSA is an unsupervised way of uncovering synonyms in a collection of documents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df = pd.read_csv('Reviews.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Id</th>\n",
       "      <th>ProductId</th>\n",
       "      <th>UserId</th>\n",
       "      <th>ProfileName</th>\n",
       "      <th>HelpfulnessNumerator</th>\n",
       "      <th>HelpfulnessDenominator</th>\n",
       "      <th>Score</th>\n",
       "      <th>Time</th>\n",
       "      <th>Summary</th>\n",
       "      <th>Text</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>B001E4KFG0</td>\n",
       "      <td>A3SGXH7AUHU8GW</td>\n",
       "      <td>delmartian</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>5</td>\n",
       "      <td>1303862400</td>\n",
       "      <td>Good Quality Dog Food</td>\n",
       "      <td>I have bought several of the Vitality canned d...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>B00813GRG4</td>\n",
       "      <td>A1D87F6ZCVE5NK</td>\n",
       "      <td>dll pa</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1346976000</td>\n",
       "      <td>Not as Advertised</td>\n",
       "      <td>Product arrived labeled as Jumbo Salted Peanut...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>B000LQOCH0</td>\n",
       "      <td>ABXLMWJIXXAIN</td>\n",
       "      <td>Natalia Corres \"Natalia Corres\"</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>1219017600</td>\n",
       "      <td>\"Delight\" says it all</td>\n",
       "      <td>This is a confection that has been around a fe...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>B000UA0QIQ</td>\n",
       "      <td>A395BORC6FGVXV</td>\n",
       "      <td>Karl</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>1307923200</td>\n",
       "      <td>Cough Medicine</td>\n",
       "      <td>If you are looking for the secret ingredient i...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>B006K2ZZ7K</td>\n",
       "      <td>A1UQRSCLF8GW1T</td>\n",
       "      <td>Michael D. Bigham \"M. Wassir\"</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>1350777600</td>\n",
       "      <td>Great taffy</td>\n",
       "      <td>Great taffy at a great price.  There was a wid...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Id   ProductId          UserId                      ProfileName  \\\n",
       "0   1  B001E4KFG0  A3SGXH7AUHU8GW                       delmartian   \n",
       "1   2  B00813GRG4  A1D87F6ZCVE5NK                           dll pa   \n",
       "2   3  B000LQOCH0   ABXLMWJIXXAIN  Natalia Corres \"Natalia Corres\"   \n",
       "3   4  B000UA0QIQ  A395BORC6FGVXV                             Karl   \n",
       "4   5  B006K2ZZ7K  A1UQRSCLF8GW1T    Michael D. Bigham \"M. Wassir\"   \n",
       "\n",
       "   HelpfulnessNumerator  HelpfulnessDenominator  Score        Time  \\\n",
       "0                     1                       1      5  1303862400   \n",
       "1                     0                       0      1  1346976000   \n",
       "2                     1                       1      4  1219017600   \n",
       "3                     3                       3      2  1307923200   \n",
       "4                     0                       0      5  1350777600   \n",
       "\n",
       "                 Summary                                               Text  \n",
       "0  Good Quality Dog Food  I have bought several of the Vitality canned d...  \n",
       "1      Not as Advertised  Product arrived labeled as Jumbo Salted Peanut...  \n",
       "2  \"Delight\" says it all  This is a confection that has been around a fe...  \n",
       "3         Cough Medicine  If you are looking for the secret ingredient i...  \n",
       "4            Great taffy  Great taffy at a great price.  There was a wid...  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(568454, 10)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TF-IDF\n",
    "\n",
    "TFIDF is an information retrieval technique that weighs a term’s frequency (TF) and its inverse document frequency (IDF). Each word has its respective TF and IDF score. The product of the TF and IDF scores of a word is called the TFIDF weight of that word.\n",
    "\n",
    "Put simply, the higher the TFIDF score (weight), the rarer the word and vice versa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TfidfVectorizer(analyzer='word', binary=False, decode_error='strict',\n",
       "        dtype=<class 'numpy.int64'>, encoding='utf-8', input='content',\n",
       "        lowercase=True, max_df=1.0, max_features=None, min_df=1,\n",
       "        ngram_range=(1, 1), norm='l2', preprocessor=None, smooth_idf=True,\n",
       "        stop_words=None, strip_accents=None, sublinear_tf=False,\n",
       "        token_pattern='(?u)\\\\b\\\\w\\\\w+\\\\b', tokenizer=None, use_idf=True,\n",
       "        vocabulary=None)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "\n",
    "tfidf = TfidfVectorizer()\n",
    "tfidf.fit(df['Text'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = tfidf.transform(df['Text'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Product arrived labeled as Jumbo Salted Peanuts...the peanuts were actually small sized unsalted. Not sure if this was an error or if the vendor intended to represent the product as \"Jumbo\".'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['Text'][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In reference to the above sentence, we can check out tf-idf scores for a few words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.37995462060339136]\n"
     ]
    }
   ],
   "source": [
    "print([X[1, tfidf.vocabulary_['peanuts']]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.530965343023095]\n"
     ]
    }
   ],
   "source": [
    "print([X[1, tfidf.vocabulary_['jumbo']]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.2302711360436964]\n"
     ]
    }
   ],
   "source": [
    "print([X[1, tfidf.vocabulary_['error']]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Among these three words, \"peanut\", \"jumbo\" and \"error\", tf-idf gives the highest weight to \"jumbo\". This indicates that \"jumbo\" is a much rarer word than \"peanut\" and \"error\". This is how to use the tf-idf to indicate the importance of words or terms inside a collection of documents."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Text Classification\n",
    "\n",
    "To classify sentiment, we remove neutral score 3, then group score 4 and 5 to positive (1), and score 1 and 2 to negative (0).  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Text</th>\n",
       "      <th>Positivity</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>I have bought several of the Vitality canned d...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Product arrived labeled as Jumbo Salted Peanut...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>This is a confection that has been around a fe...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>If you are looking for the secret ingredient i...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Great taffy at a great price.  There was a wid...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                Text  Positivity\n",
       "0  I have bought several of the Vitality canned d...           1\n",
       "1  Product arrived labeled as Jumbo Salted Peanut...           0\n",
       "2  This is a confection that has been around a fe...           1\n",
       "3  If you are looking for the secret ingredient i...           0\n",
       "4  Great taffy at a great price.  There was a wid...           1"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "df.dropna(inplace=True)\n",
    "df[df['Score'] != 3]\n",
    "df['Positivity'] = np.where(df['Score'] > 3, 1, 0)\n",
    "cols = ['Id', 'ProductId', 'UserId', 'ProfileName', 'HelpfulnessNumerator', 'HelpfulnessDenominator', 'Score', 'Time', 'Summary']\n",
    "df.drop(cols, axis=1, inplace=True)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Positivity\n",
       "0    124645\n",
       "1    443766\n",
       "dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby('Positivity').size()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train test split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = df.Text\n",
    "y = df.Positivity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train set has total 426308 entries with 21.91% negative, 78.09% positive\n"
     ]
    }
   ],
   "source": [
    "print(\"Train set has total {0} entries with {1:.2f}% negative, {2:.2f}% positive\".format(len(X_train),\n",
    "                                                                             (len(X_train[y_train == 0]) / (len(X_train)*1.))*100,\n",
    "                                                                            (len(X_train[y_train == 1]) / (len(X_train)*1.))*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test set has total 142103 entries with 21.99% negative, 78.01% positive\n"
     ]
    }
   ],
   "source": [
    "print(\"Test set has total {0} entries with {1:.2f}% negative, {2:.2f}% positive\".format(len(X_test),\n",
    "                                                                             (len(X_test[y_test == 0]) / (len(X_test)*1.))*100,\n",
    "                                                                            (len(X_test[y_test == 1]) / (len(X_test)*1.))*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.metrics import accuracy_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def accuracy_summary(pipeline, X_train, y_train, X_test, y_test):\n",
    "    sentiment_fit = pipeline.fit(X_train, y_train)\n",
    "    y_pred = sentiment_fit.predict(X_test)\n",
    "    accuracy = accuracy_score(y_test, y_pred)\n",
    "    print(\"accuracy score: {0:.2f}%\".format(accuracy*100))\n",
    "    return accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv = CountVectorizer()\n",
    "rf = RandomForestClassifier(class_weight=\"balanced\")\n",
    "n_features = np.arange(10000,30001,10000)\n",
    "\n",
    "def nfeature_accuracy_checker(vectorizer=cv, n_features=n_features, stop_words=None, ngram_range=(1, 1), classifier=rf):\n",
    "    result = []\n",
    "    print(classifier)\n",
    "    print(\"\\n\")\n",
    "    for n in n_features:\n",
    "        vectorizer.set_params(stop_words=stop_words, max_features=n, ngram_range=ngram_range)\n",
    "        checker_pipeline = Pipeline([\n",
    "            ('vectorizer', vectorizer),\n",
    "            ('classifier', classifier)\n",
    "        ])\n",
    "        print(\"Test result for {} features\".format(n))\n",
    "        nfeature_accuracy = accuracy_summary(checker_pipeline, X_train, y_train, X_test, y_test)\n",
    "        result.append((n,nfeature_accuracy))\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "tfidf = TfidfVectorizer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result for trigram with stop words (Tfidf)\n",
      "\n",
      "RandomForestClassifier(bootstrap=True, class_weight='balanced',\n",
      "            criterion='gini', max_depth=None, max_features='auto',\n",
      "            max_leaf_nodes=None, min_impurity_decrease=0.0,\n",
      "            min_impurity_split=None, min_samples_leaf=1,\n",
      "            min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
      "            n_estimators=10, n_jobs=1, oob_score=False, random_state=None,\n",
      "            verbose=0, warm_start=False)\n",
      "\n",
      "\n",
      "Test result for 10000 features\n",
      "accuracy score: 90.50%\n",
      "Test result for 20000 features\n",
      "accuracy score: 90.44%\n",
      "Test result for 30000 features\n",
      "accuracy score: 90.63%\n"
     ]
    }
   ],
   "source": [
    "print(\"Result for trigram with stop words (Tfidf)\\n\")\n",
    "feature_result_tgt = nfeature_accuracy_checker(vectorizer=tfidf,ngram_range=(1, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we are done here, we should sheck the classification report."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "   negative       0.82      0.73      0.78     31250\n",
      "   positive       0.93      0.96      0.94    110853\n",
      "\n",
      "avg / total       0.90      0.91      0.90    142103\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "\n",
    "cv = CountVectorizer(max_features=30000,ngram_range=(1, 3))\n",
    "pipeline = Pipeline([\n",
    "        ('vectorizer', cv),\n",
    "        ('classifier', rf)\n",
    "    ])\n",
    "sentiment_fit = pipeline.fit(X_train, y_train)\n",
    "y_pred = sentiment_fit.predict(X_test)\n",
    "\n",
    "print(classification_report(y_test, y_pred, target_names=['negative','positive']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chi2 Feature Selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_selection import chi2\n",
    "\n",
    "tfidf = TfidfVectorizer(max_features=30000,ngram_range=(1, 3))\n",
    "X_tfidf = tfidf.fit_transform(df.Text)\n",
    "y = df.Positivity\n",
    "chi2score = chi2(X_tfidf, y)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1d5cba0fd68>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.figure(figsize=(12,8))\n",
    "scores = list(zip(tfidf.get_feature_names(), chi2score))\n",
    "chi2 = sorted(scores, key=lambda x:x[1])\n",
    "topchi2 = list(zip(*chi2[-20:]))\n",
    "x = range(len(topchi2[1]))\n",
    "labels = topchi2[0]\n",
    "plt.barh(x,topchi2[1], align='center', alpha=0.5)\n",
    "plt.plot(topchi2[1], x, '-o', markersize=5, alpha=0.8)\n",
    "plt.yticks(x, labels)\n",
    "plt.xlabel('$\\chi^2$')\n",
    "plt.show();"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
